home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / ddx / Xsun / patches / sunCG3C.c.patch < prev    next >
Encoding:
Text File  |  1991-11-05  |  6.8 KB  |  268 lines
  1. *** /tmp/,RCSt1528697    Mon Nov  4 17:41:11 1991
  2. --- sunCG3C.c    Tue Jan  8 23:00:47 1991
  3. ***************
  4. *** 37,52 ****
  5.   
  6.   #include    "sun.h"
  7.   
  8.   #include    <sys/mman.h>
  9.   #include    <pixrect/memreg.h>
  10.   /*
  11.   #include    <sundev/cg4reg.h>
  12.   */
  13.   #include    "colormap.h"
  14.   #include    "colormapst.h"
  15.   #include    "resource.h"
  16. ! #include    <struct.h>
  17.   
  18.   /*-
  19.    * The cg3 frame buffer is divided into several pieces.
  20.    *    1) an array of 8-bit pixels
  21. --- 37,65 ----
  22.   
  23.   #include    "sun.h"
  24.   
  25. + 
  26.   #include    <sys/mman.h>
  27. + #include    <kernel/vmMach.h>
  28. + #ifndef    sprite
  29.   #include    <pixrect/memreg.h>
  30.   /*
  31.   #include    <sundev/cg4reg.h>
  32.   */
  33. + #include    <struct.h>
  34. + #endif    sprite
  35. + 
  36. + #include <sys/types.h>
  37.   #include    "colormap.h"
  38.   #include    "colormapst.h"
  39.   #include    "resource.h"
  40. ! 
  41. ! #include "sys/ioctl.h"
  42. ! 
  43. ! #include "sys/fb.h"
  44. ! #undef MAP_NEW
  45.   
  46. + struct fbtype fbType;
  47. + 
  48.   /*-
  49.    * The cg3 frame buffer is divided into several pieces.
  50.    *    1) an array of 8-bit pixels
  51. ***************
  52. *** 86,91 ****
  53. --- 99,105 ----
  54.   static CG3ACPtr CG3ACfb = NULL;
  55.   static CG3BCPtr CG3BCfb = NULL;
  56.   
  57. + 
  58.   static int  sunCG3CScreenIndex;
  59.   
  60.   /* XXX - next line means only one CG3 - fix this */
  61. ***************
  62. *** 100,106 ****
  63.       int        index, count;
  64.       u_char    *rmap, *gmap, *bmap;
  65.   {
  66. !     struct fbcmap sunCmap;
  67.   
  68.       sunCmap.index = index;
  69.       sunCmap.count = count;
  70. --- 114,120 ----
  71.       int        index, count;
  72.       u_char    *rmap, *gmap, *bmap;
  73.   {
  74. !     fbcmap sunCmap;
  75.   
  76.       sunCmap.index = index;
  77.       sunCmap.count = count;
  78. ***************
  79. *** 163,168 ****
  80. --- 177,183 ----
  81.       break;
  82.       }
  83.       (void) ioctl(sunFbs[pScreen->myNum].fd, FBIOSVIDEO, &state);
  84. + 
  85.       return( TRUE );
  86.   }
  87.   
  88. ***************
  89. *** 191,197 ****
  90.       pScreen->CloseScreen = (Bool (*)()) pScreen->devPrivates[sunCG3CScreenIndex].ptr;
  91.       ret = (*pScreen->CloseScreen) (i, pScreen);
  92.   
  93. ! /* the following 2 lines are to fix rr clear_colormap bug */
  94.       rmap[255] = gmap[255] = bmap[255] = 0;
  95.       sunCG3CUpdateColormap(pScreen, 255, 1, rmap, gmap, bmap);
  96.   
  97. --- 206,212 ----
  98.       pScreen->CloseScreen = (Bool (*)()) pScreen->devPrivates[sunCG3CScreenIndex].ptr;
  99.       ret = (*pScreen->CloseScreen) (i, pScreen);
  100.   
  101. !     /* the following 2 lines are to fix rr clear_colormap bug */
  102.       rmap[255] = gmap[255] = bmap[255] = 0;
  103.       sunCG3CUpdateColormap(pScreen, 255, 1, rmap, gmap, bmap);
  104.   
  105. ***************
  106. *** 380,387 ****
  107. --- 395,406 ----
  108.       char          **argv;       /* The arguments themselves. Don't change! */
  109.   {
  110.       if (!cfbScreenInit (pScreen,
  111. + #ifndef sprite
  112.               (sunFbs[index].info.fb_width == CG3A_WIDTH) ?
  113.               (int *) CG3ACfb->cpixel : (int *) CG3BCfb->cpixel,
  114. + #else
  115. +             sunFbs[index].fb,
  116. + #endif
  117.               sunFbs[index].info.fb_width,
  118.               sunFbs[index].info.fb_height,
  119.               monitorResolution, monitorResolution,
  120. ***************
  121. *** 460,496 ****
  122.       }
  123.   #else    _MAP_NEW
  124.       if (fbType.fb_width == CG3A_WIDTH) {
  125.       CG3ACfb = (CG3ACPtr) valloc(CG3AC_MONOLEN + 
  126.           CG3AC_ENBLEN + CG3AC_IMAGELEN);
  127.       if (CG3ACfb == (CG3ACPtr) NULL) {
  128.           ErrorF("Could not allocate room for frame buffer.\n");
  129.           return FALSE;
  130.       }
  131.   
  132.       if (mmap((caddr_t) CG3ACfb, CG3AC_MONOLEN + 
  133.           CG3AC_ENBLEN + CG3AC_IMAGELEN,
  134.           PROT_READ | PROT_WRITE,
  135.           MAP_SHARED, fd, 0) < 0) {
  136.           Error("Mapping cg3c");
  137.           (void) close(fd);
  138.           return FALSE;
  139.       }
  140.       }
  141.       else if (fbType.fb_width == CG3B_WIDTH) {
  142.       CG3BCfb = (CG3BCPtr) valloc(CG3BC_MONOLEN + 
  143.           CG3BC_ENBLEN + CG3BC_IMAGELEN);
  144.       if (CG3BCfb == (CG3BCPtr) NULL) {
  145.           ErrorF("Could not allocate room for frame buffer.\n");
  146.           return FALSE;
  147.       }
  148. ! 
  149.       if (mmap((caddr_t) CG3BCfb, CG3BC_MONOLEN + 
  150.           CG3BC_ENBLEN + CG3BC_IMAGELEN,
  151.           PROT_READ | PROT_WRITE,
  152.           MAP_SHARED, fd, 0) < 0) {
  153.           Error("Mapping cg3c");
  154.           (void) close(fd);
  155.           return FALSE;
  156.       }
  157.       }
  158.       else {
  159. --- 479,552 ----
  160.       }
  161.   #else    _MAP_NEW
  162.       if (fbType.fb_width == CG3A_WIDTH) {
  163. + #ifdef sprite
  164. +     int    sizeToUse;
  165. + 
  166. +     sizeToUse = ((fbType.fb_size + VMMACH_SEG_SIZE) & ~(VMMACH_SEG_SIZE-1))
  167. +         + VMMACH_SEG_SIZE;
  168. +     CG3ACfb = (CG3ACPtr) malloc(sizeToUse);
  169. +     printf("original CG3ACfb addr: 0x%x, original size: 0x%x\n",
  170. +         CG3ACfb, sizeToUse);
  171. + #else
  172.       CG3ACfb = (CG3ACPtr) valloc(CG3AC_MONOLEN + 
  173.           CG3AC_ENBLEN + CG3AC_IMAGELEN);
  174. + #endif /* sprite */
  175.       if (CG3ACfb == (CG3ACPtr) NULL) {
  176.           ErrorF("Could not allocate room for frame buffer.\n");
  177.           return FALSE;
  178.       }
  179.   
  180. + #ifdef sprite
  181. +     CG3ACfb = (CG3ACPtr) mmap((caddr_t) CG3ACfb, fbType.fb_size,
  182. +         PROT_READ | PROT_WRITE,
  183. +         MAP_SHARED, fd, 0);
  184. +     if (CG3ACfb == (CG3ACPtr) NULL) {
  185. + #else
  186.       if (mmap((caddr_t) CG3ACfb, CG3AC_MONOLEN + 
  187.           CG3AC_ENBLEN + CG3AC_IMAGELEN,
  188.           PROT_READ | PROT_WRITE,
  189.           MAP_SHARED, fd, 0) < 0) {
  190. + #endif /* sprite */
  191.           Error("Mapping cg3c");
  192.           (void) close(fd);
  193.           return FALSE;
  194. +     } else {
  195. +         printf("new addr for CG3ACfb: 0x%x\n", CG3ACfb);
  196.       }
  197.       }
  198.       else if (fbType.fb_width == CG3B_WIDTH) {
  199. + #ifdef sprite
  200. +     int    sizeToUse;
  201. + 
  202. +     sizeToUse = ((fbType.fb_size + VMMACH_SEG_SIZE) & ~(VMMACH_SEG_SIZE-1))
  203. +         + VMMACH_SEG_SIZE;
  204. +     CG3BCfb = (CG3BCPtr) malloc(sizeToUse);
  205. +     printf("original CG3BCfb addr: 0x%x, original size: 0x%x\n",
  206. +         CG3BCfb, sizeToUse);
  207. + #else
  208.       CG3BCfb = (CG3BCPtr) valloc(CG3BC_MONOLEN + 
  209.           CG3BC_ENBLEN + CG3BC_IMAGELEN);
  210. + #endif /* sprite */
  211.       if (CG3BCfb == (CG3BCPtr) NULL) {
  212.           ErrorF("Could not allocate room for frame buffer.\n");
  213.           return FALSE;
  214.       }
  215. ! #ifdef sprite
  216. !     CG3BCfb = (CG3BCPtr) mmap((caddr_t) CG3BCfb, fbType.fb_size,
  217. !         PROT_READ | PROT_WRITE,
  218. !         MAP_SHARED, fd, 0);
  219. !     if (CG3BCfb == (CG3BCPtr) NULL) {
  220. ! #else
  221.       if (mmap((caddr_t) CG3BCfb, CG3BC_MONOLEN + 
  222.           CG3BC_ENBLEN + CG3BC_IMAGELEN,
  223.           PROT_READ | PROT_WRITE,
  224.           MAP_SHARED, fd, 0) < 0) {
  225. + #endif /* sprite */
  226.           Error("Mapping cg3c");
  227.           (void) close(fd);
  228.           return FALSE;
  229. +     } else {
  230. +         printf("new addr for CG3BCfb: 0x%x\n", CG3BCfb);
  231.       }
  232.       }
  233.       else {
  234. ***************
  235. *** 500,512 ****
  236.       }
  237.   #endif    _MAP_NEW
  238.   
  239. -     sunFbs[index].fd = fd;
  240.       sunFbs[index].info = fbType;
  241.   /*  sunFbs[index].EnterLeave = sunCG3CSwitch;    */
  242. !     if (fbType.fb_width == CG3A_WIDTH)
  243.       sunFbs[index].fb = (pointer) CG3ACfb;
  244. !     else
  245.       sunFbs[index].fb = (pointer) CG3BCfb;
  246.       sunSupportsDepth8 = TRUE;
  247.       return TRUE;
  248.   }
  249. --- 556,573 ----
  250.       }
  251.   #endif    _MAP_NEW
  252.   
  253.       sunFbs[index].info = fbType;
  254.   /*  sunFbs[index].EnterLeave = sunCG3CSwitch;    */
  255. ! #ifndef sprite
  256. !     sunFbs[index].fb = (pointer) fb_Addr.fb_buffer;
  257. ! #else
  258. !     if (fbType.fb_width == CG3A_WIDTH) {
  259.       sunFbs[index].fb = (pointer) CG3ACfb;
  260. !     } else if (fbType.fb_width == CG3B_WIDTH) {
  261.       sunFbs[index].fb = (pointer) CG3BCfb;
  262. +     }
  263. + #endif /*sprite*/
  264. +     sunFbs[index].fd = fd;
  265.       sunSupportsDepth8 = TRUE;
  266.       return TRUE;
  267.   }
  268.